home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / fpkpas92.zip / SRCRTL.ZIP / RTL / DOS / SYSTEMH.INC < prev    next >
Text File  |  1997-07-01  |  10KB  |  284 lines
  1. {****************************************************************************
  2.  
  3.                        Copyright (c) 1993,1997 by
  4.                     Florian Klämpfl & Michael Spiegel
  5.  
  6.  ****************************************************************************}
  7.  
  8. { diese Datei enthaelt die betriebssystemunabhaengigen Deklarationen der }
  9. { Unit System                                  }
  10.  
  11.     type    
  12.        shortint = -128..127;
  13.  
  14.        { longint ist in TP als  -2147483648..2147483647 deklariert,  }
  15.        { aber dies kann in dieser PP-Version nicht ueberstzt werden, }
  16.        { werden, da  der Compiler erst 2147483648 versucht in eine   }
  17.        { Int-Konstante umzuwandeln, um dann diese Zahl spaeter zu    }
  18.        { negieren, aber da macht VAL natürlich nicht mit             }
  19.  
  20.        { also Zweierkomplementdarstellung:                           }
  21.        longint  = $80000000..$7fffffff;
  22.  
  23.        integer  = -32768..32767;
  24.        byte     = 0..255;
  25.        word     = 0..65535;
  26.  
  27.     const
  28.        { max. Werte für longint und int }
  29.        maxlongint = $7fffffff;
  30.        maxint = 32767;
  31.  
  32.     type
  33.        { Turbo Pascal Fließkommatypen wenigstens deklarieren: }
  34.        double = real;
  35.  
  36. {$ifdef VER0_6}
  37.        extended = real;
  38.        single = real;
  39. {$endif VER0_6}
  40.  
  41.        { Nullterminierte Strings }
  42.        pchar = ^char;
  43.        ppchar = ^pchar;
  44.  
  45. {$ifdef VER0_6}
  46.        fixed = longint;
  47. {$endif}
  48.  
  49.     const
  50.        { Kompatibilität zu TP }
  51.        test8086 : byte = 2; { immer i386 oder neuer }
  52.        test8087 : byte = 3; { immer 387 oder höher; notfalls emuliert }
  53.        erroraddr : pointer = nil;
  54.        errorcode : word = 0;
  55.       { max level in dumping on error }
  56.        max_frame_dump : word = 20;
  57.     var
  58.        { Standartein- und ausgabe }
  59.        output,input : text;
  60.        exitproc : pointer;
  61.        inoutres : word;
  62.          var stackbottom : longint;
  63.          var loweststack : longint;
  64.  
  65.     procedure runerror(w : word);
  66.     procedure move(var source,dest;count : longint);
  67.     procedure fillchar(var x;count : longint;value : char);
  68.     procedure fillchar(var x;count : longint;value : byte);
  69.     procedure fillword(var x;count : longint;value : word);
  70.     
  71.     function lo(w : word) : byte;
  72.     function hi(w : word) : byte;
  73.     function lo(i : integer) : byte;
  74.     function hi(i : integer) : byte;
  75.     
  76.     function lo(l : longint) : word;
  77.     function hi(l : longint) : word;
  78.     
  79.     function ord(c : char) : byte;
  80.     function ord(b : boolean) : byte;
  81.     function chr(b : byte) : char;
  82.     
  83.     function length(s : string) : byte;
  84.  
  85.     procedure str(l : longint;var s : string);
  86.     procedure str(d : double;var s : string);
  87.     procedure str(i : integer;var s : string);
  88.     procedure str(si : shortint;var s : string);
  89.     procedure str(b : byte;var s : string);
  90.     procedure str(w : word;var s : string);
  91.     procedure val(const s : string;var v : longint;var code : word);
  92.     procedure val(const s : string;var v : longint);
  93.     procedure val(const s : string;var b : byte);
  94.     procedure val(const s : string;var b : byte;var code : word);
  95.     procedure val(const s : string;var d : double;var code : word);
  96.  
  97.     procedure inc(var i : longint);
  98.     procedure inc(var i : integer);
  99.     procedure inc(var i : word);
  100.     procedure inc(var i : shortint);
  101.     procedure inc(var i : byte);
  102.  
  103.     procedure dec(var i : longint);
  104.     procedure dec(var i : integer);
  105.     procedure dec(var i : word);
  106.     procedure dec(var i : shortint);
  107.     procedure dec(var i : byte);
  108.  
  109.     procedure dec(var i : longint;a : longint);
  110.     procedure inc(var i : longint;a : longint);
  111.     procedure dec(var i : word;a : longint);
  112.     procedure inc(var i : word;a : longint);
  113.     procedure dec(var i : integer;a : longint);
  114.     procedure inc(var i : integer;a : longint);
  115.     procedure dec(var i : byte;a : longint);
  116.     procedure inc(var i : byte;a : longint);
  117.     procedure dec(var i : shortint;a : longint);
  118.     procedure inc(var i : shortint;a : longint);
  119.     
  120.     function random(l : longint) : longint;
  121.     procedure halt;
  122.     procedure halt(errnum : byte);
  123.     procedure randomize;
  124.     function paramcount : longint;
  125.     function paramstr(l : longint) : string;
  126.  
  127.     { Speicherverwaltung }
  128.     procedure getmem(var p : pointer;size : longint);
  129.     procedure freemem(var p : pointer;size : longint);
  130.     function memavail : longint;
  131.     function maxavail : longint;
  132.  
  133.     { Dateiverwaltung }
  134.     procedure assign(var f : file;const name : string);
  135.     procedure rewrite(var f : file;l : word);
  136.     procedure rewrite(var f : file);
  137.     procedure reset(var f : file;l : word);
  138.     procedure reset(var f : file);
  139. {$IfDef typedfile }
  140.     procedure assign(var f : typedfile;const name : string);
  141.     procedure rewrite(var f : typedfile);
  142.     procedure reset(var f : typedfile);
  143. {    procedure close(var f : typedfile);
  144.     function filepos(var f : typedfile) : longint;
  145.     function filesize(var f : typedfile) : longint;
  146.     procedure seek(var f : typedfile;pos : longint);
  147.     procedure erase(var f : typedfile);
  148.     procedure rename(var f : typedfile;const s : string);
  149.     function eof(var f : typedfile) : boolean;}
  150. {$endIf typedfile }
  151.     procedure append(var t : text);
  152.     procedure blockwrite(var f : file;var buf;count : longint);
  153.     procedure blockread(var f : file;var buf;count : longint);
  154.     procedure blockread(var f : file;var buf;count : longint;var result : longint);
  155.     procedure blockread(var f : file;var buf;count : word;var result : word);
  156. {$IfDef GO32V2}
  157.     type
  158.        trealregs=record
  159.           realedi,realesi,realebp,realres,
  160.           realebx,realedx,realecx,realeax : longint;
  161.           realflags,
  162.           reales,realds,realfs,realgs,
  163.           realip,realcs,realsp,realss : word;
  164.        end;
  165. {$PACKRECORDS 1}
  166.        t_go32_info_block = record
  167.        size_of_this_structure_in_bytes : longint; {offset 0}
  168.        linear_address_of_primary_screen : longint; {offset 4}
  169.        linear_address_of_secondary_screen : longint; {offset 8}
  170.        linear_address_of_transfer_buffer : longint; {offset 12}
  171.        size_of_transfer_buffer : longint; {offset 16}
  172.        pid : longint; {offset 20}
  173.        master_interrupt_controller_base : byte; {offset 24}
  174.        slave_interrupt_controller_base : byte; {offset 25}
  175.        selector_for_linear_memory : word; {offset 26}
  176.        linear_address_of_stub_info_structure : longint; {offset 28}
  177.        linear_address_of_original_psp : longint; {offset 32}
  178.        run_mode : word; {offset 36}
  179.        run_mode_info : word; {offset 38}
  180.        end;
  181.  
  182.        t_stub_info   = record
  183.        magic         : array[0..15] of char;
  184.        size          : longint;
  185.        minstack      : longint;
  186.        memory_handle : longint;
  187.        initial_size  : longint;
  188.        minkeep       : word;
  189.        ds_selector   : word;
  190.        ds_segment    : word;
  191.        psp_selector  : word;
  192.        cs_selector   : word;
  193.        env_size      : word;
  194.        basename      : array[0..7] of char;
  195.        argv0         : array [0..15] of char;
  196.        dpmi_server   : array [0..15] of char;
  197.        end;
  198.        p_stub_info   = ^t_stub_info;
  199.  
  200. var go32_info_block : t_go32_info_block;
  201.          dos_argv0 : pchar;
  202. const    stub_info : p_stub_info = nil;
  203.          environ : ppchar = nil;
  204.  
  205.     function heapsize : longint;
  206.     procedure doswrite(h,addr,len : longint);
  207.     function dosread(h,addr,len : longint) : longint;
  208.     procedure syscopyfromdos(addr : longint; len : longint);
  209.     procedure syscopytodos(addr : longint; len : longint);
  210.     function tb : longint;
  211.     procedure sysrealintr(intnr : word;var regs : trealregs);
  212. {$EndIf GO32V2}
  213.     procedure close(var f : file);
  214.     function filepos(var f : file) : longint;
  215.     function filesize(var f : file) : longint;
  216.     procedure seek(var f : file;pos : longint);
  217.     procedure erase(var f : file);
  218.     procedure rename(var f : file;const s : string);
  219.     function eof(var f : file) : boolean;
  220.  
  221.     procedure assign(var t : text;const s : string);
  222.     procedure rewrite(var t : text);
  223.     procedure reset(var t : text);
  224.     procedure close(var t : text);
  225.     function eof(var t : text) : boolean;
  226.     function eof : boolean;
  227.     function eoln(var t : text) : boolean;
  228.     function eoln : boolean;
  229.     procedure flush(var t : text);
  230.     procedure erase(var t : text);
  231.     procedure rename(var t : text;const s : string);
  232.  
  233.     function ioresult : word;
  234.     
  235.     procedure chdir(const s : string);
  236.     procedure mkdir(const s : string);
  237.     procedure rmdir(const s : string);
  238.     procedure getdir(drivenr : byte;var dir : string);
  239.  
  240.     { mathe routines }
  241.     function abs(l : longint) : longint;
  242.     function sqr(l : longint) : longint;
  243.     function odd(l : longint) : boolean;
  244.  
  245.     function ptr(sel,off : word) : pointer;
  246.  
  247.     { float mathe routines }
  248.     {$I MATHH.INC}
  249.  
  250.     { string handling}
  251.     function copy(const s : string;index : integer;count : byte) : string;
  252.     procedure delete(var s : string;index : integer;count : integer);
  253.     procedure insert(const source : string;var s : string;index : integer);
  254.     function pos(const substr : string;const s : string) : byte;
  255.     function upcase(c : char) : char;
  256.     function upcase(const s : string) : string;
  257.     function lowercase(c : char) : char;
  258.     function lowercase(const s : string) : string;
  259.     function space(b : byte) : string;
  260.     function hexstr(val : longint;cnt : byte) : string;
  261.     function binstr(val : longint;cnt : byte) : string;
  262.  
  263.     const
  264.        fmclosed = $D7B0;
  265.        fminput = $D7B1;
  266.        fmoutput = $D7B2;
  267.        fminout = $D7B3;
  268.        fmappend = $D7B4;
  269.  
  270.        filemode : byte = 2;
  271.  
  272. { old version doesn't like this }
  273. {$ifdef dummy}
  274. {$ifndef VER0_6_5}
  275. {$ifndef VER0_6_4}
  276.     type
  277.        tobject = class
  278.           constructor create;
  279.           destructor free;virtual;
  280.        end;
  281. {$endif}
  282. {$endif}
  283. {$endif}
  284.